#include "Test_Regression.h"
#include "Menu.h"
#include "Scenario.h"
#include "Animation.h"
#include "Dessiner.h"
#include "Barre_outils_animation.h"
#include "Barre_outils_dessins.h"
#include "Boite_Saisie_Outils.h"
#include "Afficher_ecran.h"
#include <clutter-gtk/clutter-gtk.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <assert.h>
#include <stdlib.h>

/* Effectue tout une série de test vérifiant que les modules fonctionnent et que les
   champ de la structure sont conformes*/
void TestStructureCarreManuel(Carre *car)
{
  Coordonnees c={50.0,50.0};
  Couleur cl={1.0,0.2,0.5};
  Couleur cl2={0.2,0.8,0.7};

  printf("\n");
  printf("Test de la structure Carre manuellement\n");
  printf("Test Initialisation Carre ....");
  InitCarre(car);
  assert(car->coordoCar.x==0.0 &&
	 car->coordoCar.y==0.0 &&
	 car->contour.r==0.0 &&
	 car->contour.g==0.0 &&
	 car->contour.b==0.0 &&
	 car->fond.r==0.0 &&
	 car->fond.g==0.0 &&
	 car->fond.b==0.0 &&
	 car->dim==0.0 &&
	 car->epaisseur_contour==0.0); 
  printf("Initialisation Carre : OK\n");
  printf("\n");
  printf("Test remplissage du Carre ....");
  printf("Avec les valeurs suivantes :\n");
  printf("Dim : %g\n",50.0);
  printf("Epaisseur contour: %g\n",1.2);
  printf("Valeur Fond et Contour Rouge: %g\n",cl.r);
  printf("Valeur Fond et Contour Vert: %g\n",cl.g);
  printf("Valeur Fond et Contour Bleu: %g\n",cl.b);
  printf("Valeur Coordonnees X : %g\n",c.x);
  printf("Valeur Cooordonees Y : %g\n",c.y);

  printf("\n");
  printf("  Test de la fonction CreerCarre avec les valeurs ci-dessus\n");
  printf("\n");

  CreerCarre(car,50.0,1.2,cl,cl,c);
  assert(car->dim==50.0 &&
	 car->epaisseur_contour==1.2 &&
	 car->fond.r==cl.r &&
	 car->fond.g==cl.g &&
	 car->fond.b==cl.b &&
	 car->contour.r== cl.r &&
	 car->contour.g== cl.g &&
	 car->contour.b== cl.b &&
	 car->coordoCar.x==c.x &&
	 car->coordoCar.y==c.y);

  printf("Dim Carre : %g\n",car->dim);
  printf("Epaisseur contour Carre : %g\n",car->epaisseur_contour);
  printf("Valeur Couleur Rouge Carre : %g\n",car->fond.r);
  printf("Valeur Couleur Vert Carre : %g\n",car->fond.g);
  printf("Valeur Couleur Bleu Carre : %g\n",car->fond.b);
  printf("Valeur Couleur Contour Rouge Carre : %g\n",car->contour.r);
  printf("Valeur Couleur Vert Contour Carre : %g\n",car->contour.g);
  printf("Valeur Couleur Bleu Contour  Carre : %g\n",car->contour.b);
  printf("Valeur Coordonnees X Carre : %g\n",car->coordoCar.x);
  printf("Valeur Cooordonees Y Carre : %g\n",car->coordoCar.y);

  printf(" Remplissage du Carre : OK\n");
   
  printf("\n");
  printf("Test Modifier la couleur de fond du Carre avec les valeurs ci-dessous :\n");
  printf("\n");

  printf("R : %g\n",cl2.r);
  printf("V : %g\n",cl2.g);
  printf("B : %g\n",cl2.b);

  printf("Test des fonctions de modification du Carre ....\n");
  ModifierFondCarre(car,cl2);
  assert(car->fond.r==cl2.r &&
	 car->fond.g==cl2.g &&
	 car->fond.b==cl2.b);

  printf("Valeur Couleur Rouge Carre : %g\n",car->fond.r);
  printf("Valeur Couleur Vert Carre : %g\n",car->fond.g);
  printf("Valeur Couleur Bleu Carre : %g\n",car->fond.b);
 
  
  printf("Modification de la taille du Carre avec la valeur : 60\n");
  ModifierTailleCarre(car,60.0);
  assert(car->dim==60.0);
  printf("Dim Carre : %g\n",car->dim);

  printf("\n");
  printf("Test de la fonction ModifierContourCarre\n");
  printf("\n");

  ModifierContourCarre(car,1.2,cl2);
  assert(car->contour.r==cl2.r &&
	 car->contour.g==cl2.g &&
	 car->contour.b==cl2.b &&
	 car->epaisseur_contour==1.2);
 
  printf("Valeur Couleur Contour Rouge Carre : %g\n",car->contour.r);
  printf("Valeur Couleur Vert Contour Carre : %g\n",car->contour.g);
  printf("Valeur Couleur Bleu Contour  Carre : %g\n",car->contour.b);
  printf("Epaisseur contour Carre : %g\n",car->epaisseur_contour);

  printf("\n");
  printf("Test de la fonction Modification Coordonnees Carre\n");
  printf("\n");
  ModifierCoordonneesCarre(car,c);
  assert(car->coordoCar.x==50.0 &&
	 car->coordoCar.y==50.0);

  printf("Valeur Coordonnees X Carre : %g\n",car->coordoCar.x);
  printf("Valeur Cooordonees Y Carre : %g\n",car->coordoCar.y);
  
  printf("Test du Module Carre manuellement : OK\n");
}

void TestStructureRectangleManuel(Rectangle * rec)
{
  Coordonnees c={50.0,50.0};
  Couleur cl={1.0,0.2,0.5};
  Couleur cl2={0.2,0.8,0.7};
  
  printf("\n");
  printf("\n");
  printf("Test de la structure Rectangle manuellement\n");
  printf("Test Initialisation Rectangle ....");

  InitRectangle(rec);
  assert(rec->coordoRec.x==0 &&
	 rec->coordoRec.y==0 &&
	 rec->contour.r==0 &&
	 rec->contour.g==0 &&
	 rec->contour.b==0 &&
	 rec->fond.r==0 &&
	 rec->fond.g==0 &&
	 rec->fond.b==0 &&
	 rec->dimX==0 &&
	 rec->dimY==0 &&
	 rec->epaisseur_contour==0);

  printf("Initialisation Rectangle : OK\n");
  printf("\n");
  printf("Test remplissage du Rectangle ....");
  printf("Avec les valeurs suivantes :\n");
  printf("DimX : %g\n",50.0);
  printf("DimX : %g\n",60.0);
  printf("Epaisseur contour: %g\n",1.2);
  printf("Valeur Fond et Contour Rouge: %g\n",cl.r);
  printf("Valeur Fond et Contour Vert: %g\n",cl.g);
  printf("Valeur Fond et Contour Bleu: %g\n",cl.b);
  printf("Valeur Coordonnees X : %g\n",c.x);
  printf("Valeur Cooordonees Y : %g\n",c.y);

  printf("\n");
  printf("  Test de la fonction CreerRectangle avec les valeurs ci-dessus\n");
  printf("\n");

  CreerRectangle(rec,50.0,60.0,1.2,cl,cl,c);
  assert(rec->coordoRec.x==50.0 &&
	 rec->coordoRec.y==50.0 &&
	 rec->contour.r==1.0 &&
	 rec->contour.g==0.2 &&
	 rec->contour.b==0.5 &&
	 rec->fond.r==1.0 &&
	 rec->fond.g==0.2 &&
	 rec->fond.b==0.5 &&
	 rec->dimX==50.0 &&
	 rec->dimY==60.0 &&
	 rec->epaisseur_contour==1.2);

  printf("Dimx : %g - DimY : %g\n",rec->dimX,rec->dimY);
  printf("Epaisseur contour rectangle : %g\n",rec->epaisseur_contour);
  printf("Valeur Couleur Rouge rectangle : %g\n",rec->fond.r);
  printf("Valeur Couleur Vert rectangle : %g\n",rec->fond.g);
  printf("Valeur Couleur Bleu rectangle : %g\n",rec->fond.b);
  printf("Valeur Couleur Contour Rouge rectangle : %g\n",rec->contour.r);
  printf("Valeur Couleur Vert Contour rectangle : %g\n",rec->contour.g);
  printf("Valeur Couleur Bleu Contour  rectangle : %g\n",rec->contour.b);
  printf("Valeur Coordonnees X rectangle : %g\n",rec->coordoRec.x);
  printf("Valeur Cooordonees Y rectangle : %g\n",rec->coordoRec.y);


  printf("Test Modifier la couleur de fond du Rectangle avec les valeurs ci-dessous :\n");
  printf("\n");

  printf("R : %g\n",cl2.r);
  printf("V : %g\n",cl2.g);
  printf("B : %g\n",cl2.b);

  printf("Test des fonctions de modification du Rectangle ....\n");
  ModifierFondRectangle(rec,cl2);
  assert(rec->fond.r==cl2.r &&
	 rec->fond.g==cl2.g &&
	 rec->fond.b==cl2.b);

  printf("Valeur Couleur Rouge Rectangle : %g\n",rec->fond.r);
  printf("Valeur Couleur Vert Rectangle : %g\n",rec->fond.g);
  printf("Valeur Couleur Bleu rectangle : %g\n",rec->fond.b);
  printf("Modification de la taille du Rectangle\n");

  ModifierTailleRectangle(rec,50.0,70.0);
  assert(rec->dimX==50.0 &&
	 rec->dimY==70.0);

  printf("DimX : %g - DimY : %g\n",rec->dimX,rec->dimY);
  printf("\n");
  printf("Test de la fonction ModifierContourRectangle\n");
  printf("\n");

  ModifierContourRectangle(rec,1.2,cl);
  assert(rec->contour.r==1.0 &&
	 rec->contour.g==0.2 &&
	 rec->contour.b==0.5 &&
	 rec->epaisseur_contour==1.2);
  
  printf("Valeur Couleur Contour Rouge Rectangle : %g\n",rec->contour.r);
  printf("Valeur Couleur Vert Contour Rectangle : %g\n",rec->contour.g);
  printf("Valeur Couleur Bleu Contour Rectangle : %g\n",rec->contour.b);
  printf("Epaisseur contour Rectangle : %g\n",rec->epaisseur_contour);

  printf("\n");
  printf("Test de la fonction Modification Coordonnees Rectangle\n");
  printf("\n");
  ModifierCoordonneesRectangle(rec,c);
  assert(rec->coordoRec.x==50.0 &&
	 rec->coordoRec.y==50.0);

  printf("Valeur Coordonnees X Rectangle : %g\n",rec->coordoRec.x);
  printf("Valeur Cooordonees Y Rectangle : %g\n",rec->coordoRec.y);
  printf("Test du Module Rectangle manuellement : OK\n");
}

void TestStructureCercleManuel(Cercle *cer)
{
  Coordonnees c={50.0,50.0};
  Couleur cl={1.0,0.2,0.5};
  Couleur cl2={0.2,0.8,0.7};
  
  printf("\n");
  printf("\n");
  printf("Test de la structure Cercle manuellement\n");
  printf("Test Initialisation Cercle ....");

  InitCercle(cer);
  assert(cer->coordoCer.x==0 &&
	 cer->coordoCer.y==0 &&
	 cer->rayon==0 &&
	 cer->epaisseur_contour==0 &&
	 cer->contour.r==0 &&
	 cer->contour.g==0 &&
	 cer->contour.b==0 &&
	 cer->fond.r==0 &&
	 cer->fond.g==0 &&
	 cer->fond.b==0);
  
  printf("Initialisation Cercle : OK\n");
  printf("\n");
  printf("Test remplissage du Cercle ....");
  printf("Avec les valeurs suivantes :\n");
  printf("Rayon : %g\n",60.0);
  printf("Epaisseur contour: %g\n",1.2);
  printf("Valeur Fond et Contour Rouge: %g\n",cl.r);
  printf("Valeur Fond et Contour Vert: %g\n",cl.g);
  printf("Valeur Fond et Contour Bleu: %g\n",cl.b);
  printf("Valeur Coordonnees X : %g\n",c.x);
  printf("Valeur Cooordonees Y : %g\n",c.y);

  printf("\n");
  printf("  Test de la fonction CreerCercle avec les valeurs ci-dessus\n");
  printf("\n");

  CreerCercle(cer,60.0,1.2,cl,cl,c);
  assert(cer->coordoCer.x==50.0 &&
	 cer->coordoCer.y==50.0 &&
	 cer->rayon==60.0 &&
	 cer->epaisseur_contour==1.2 &&
	 cer->contour.r==1.0 &&
	 cer->contour.g==0.2 &&
	 cer->contour.b==0.5 &&
	 cer->fond.r==1.0 &&
	 cer->fond.g==0.2 &&
	 cer->fond.b==0.5);
  
  printf("Rayon : %g\n",cer->rayon);
  printf("Epaisseur contour Cercle : %g\n",cer->epaisseur_contour);
  printf("Valeur Couleur Rouge Cercle : %g\n",cer->fond.r);
  printf("Valeur Couleur Vert Cercle : %g\n",cer->fond.g);
  printf("Valeur Couleur Bleu Cercle : %g\n",cer->fond.b);
  printf("Valeur Couleur Contour Rouge Cercle : %g\n",cer->contour.r);
  printf("Valeur Couleur Vert Contour Cercle : %g\n",cer->contour.g);
  printf("Valeur Couleur Bleu Contour Cercle : %g\n",cer->contour.b);
  printf("Valeur Coordonnees X Cercle : %g\n",cer->coordoCer.x);
  printf("Valeur Cooordonees Y Cercle : %g\n",cer->coordoCer.y);

  printf("Test Modifier la couleur de fond du cercle avec les valeurs ci-dessous :\n");
  printf("\n");

  printf("R : %g\n",cl2.r);
  printf("V : %g\n",cl2.g);
  printf("B : %g\n",cl2.b);

  printf("Test des fonctions de modification du Cercle ....\n");

  ModifierFondCercle(cer,cl2);
  assert(cer->fond.r==cl2.r &&
	 cer->fond.g==cl2.g &&
	 cer->fond.b==cl2.b );

  printf("Valeur Couleur Rouge Cercle : %g\n",cer->fond.r);
  printf("Valeur Couleur Vert Cercle : %g\n",cer->fond.g);
  printf("Valeur Couleur Bleu Cercle : %g\n",cer->fond.b);
  printf("Modification de la taille du Cercle\n");

  ModifierTailleCercle(cer,40.5);
  assert(cer->rayon==40.5);

  printf("Nv Rayon : %g\n",cer->rayon);
  printf("\n");
  printf("Test de la fonction ModifierContourCercle\n");
  printf("\n");

  ModifierContourCercle(cer,1.2,cl2);
  assert(cer->epaisseur_contour==1.2 &&
	 cer->contour.r==cl2.r &&
	 cer->contour.g==cl2.g &&
	 cer->contour.b==cl2.b);
  
  printf("Valeur Couleur Contour Rouge Cercle : %g\n",cer->contour.r);
  printf("Valeur Couleur Vert Contour Cercle : %g\n",cer->contour.g);
  printf("Valeur Couleur Bleu Contour Cercle : %g\n",cer->contour.b);
  printf("Epaisseur contour Cercle : %g\n",cer->epaisseur_contour);

  printf("\n");
  printf("Test de la fonction Modification Coordonnees Cercle\n");
  printf("\n");
  
  ModifierCoordonneesCercle(cer,c);
  assert(cer->coordoCer.x==c.x &&
	 cer->coordoCer.y==c.y);
  
  printf("Valeur Coordonnees X Cercle : %g\n",cer->coordoCer.x);
  printf("Valeur Cooordonees Y Cercle : %g\n",cer->coordoCer.y);
  
  printf("Test de getDiametre : %g \n",getDiametre(50.0));
  assert(getDiametre(50.0)==100.0);

  printf("Test du Module Cercle manuellement : OK\n");
}

void TestStructurePlumeManuel(Plume * p)
{
  
  Coordonnees c={50.0,50.0};

  Coordonnees c1={60,65};
  Coordonnees c2={75,80};
  Coordonnees c3={90,90};

  Couleur cl={1.0,0.2,0.5};
  Couleur cl2={0.2,0.8,0.7};

  printf("\n");
  printf("\n");
  printf("Test de la structure Plume manuellement\n");
  printf("Test Initialisation Plume ....");

  InitPlume(p);
  assert(p->coorPl.x==0 &&
	 p->coorPl.y==0 &&
	 p->contour.r==0 &&
	 p->contour.g==0 &&
	 p->contour.b==0 &&
	 p->fond.r==0 &&
	 p->fond.g==0 &&
	 p->fond.b==0 &&
	 p->dimX==0 &&
	 p->dimY==0 &&
	 p->epaisseur_contour==0);

  printf("Initialisation Plume : OK\n");
  printf("\n");
  printf("Test remplissage de la Plume ....");
  printf("Avec les valeurs suivantes :\n");
  printf("DimX : %g\n",60.0);
  printf("DimY : %g\n",100.0);
  printf("Epaisseur contour: %g\n",1.2);
  printf("Valeur Fond et Contour Rouge: %g\n",cl.r);
  printf("Valeur Fond et Contour Vert: %g\n",cl.g);
  printf("Valeur Fond et Contour Bleu: %g\n",cl.b);
  printf("Valeur Coordonnees X : %g\n",c.x);
  printf("Valeur Cooordonees Y : %g\n",c.y);

  printf("\n");
  printf("  Test de la fonction CreerPlume avec les valeurs ci-dessus\n");
  printf("\n");

  CreerPlume(p,1.2,60.0,100.0,c,cl,cl);
  assert(p->coorPl.x==c.x &&
	 p->coorPl.y==c.y &&
	 p->contour.r==cl.r &&
	 p->contour.g==cl.g &&
	 p->contour.b==cl.b &&
	 p->fond.r==cl.r &&
	 p->fond.g==cl.g &&
	 p->fond.b==cl.b &&
	 p->dimX==60.0 &&
	 p->dimY==100.0 &&
	 p->epaisseur_contour==1.2);
  
  printf("DimX : %g - DimY : %g\n",p->dimX,p->dimY);
  printf("Epaisseur contour Plume : %g\n",p->epaisseur_contour);
  printf("Valeur Couleur Rouge Plume : %g\n",p->fond.r);
  printf("Valeur Couleur Vert Plume : %g\n",p->fond.g);
  printf("Valeur Couleur Bleu Plume : %g\n",p->fond.b);
  printf("Valeur Couleur Contour Rouge Plume : %g\n",p->contour.r);
  printf("Valeur Couleur Vert Contour Plume : %g\n",p->contour.g);
  printf("Valeur Couleur Bleu Contour Plume : %g\n",p->contour.b);
  printf("Valeur Coordonnees X Plume : %g\n",p->coorPl.x);
  printf("Valeur Cooordonees Y Plume : %g\n",p->coorPl.y);

  printf("Test Modifier la couleur de fond de la Plume avec les valeurs ci-dessous :\n");
  printf("\n");

  printf("R : %g\n",cl2.r);
  printf("V : %g\n",cl2.g);
  printf("B : %g\n",cl2.b);

  printf("Test des fonctions de modification de la Plume ....\n");
  
  ModifierFondPlume(p,cl2);
  assert(p->fond.r==cl2.r &&
	 p->fond.g==cl2.g &&
	 p->fond.b==cl2.b);
  
  printf("Valeur Couleur Rouge Plume : %g\n",p->fond.r);
  printf("Valeur Couleur Vert Plume : %g\n",p->fond.g);
  printf("Valeur Couleur Bleu Plume : %g\n",p->fond.b);
  printf("Modification de la taille du Plume\n");
   
  ModifierTaillePlume(p,60,100);
  assert(p->dimX==60 &&
	 p->dimY==100);

  printf("Nv DimX : %g - DimY : %g\n",p->dimX,p->dimY);
  printf("\n");
  printf("Test de la fonction ModifierContourPlume\n");
  printf("\n");
  
  ModifierContourPlume(p,cl2,1);
  assert(p->contour.r==cl2.r &&
	 p->contour.g==cl2.g &&
	 p->contour.b==cl2.b &&
	 p->epaisseur_contour==1);
  
  ModifierCoordonneesPlume(p,c);
  assert(p->coorPl.x==c.x &&
	 p->coorPl.y==c.y);

  RajouterPointEncrage(p,c1);
  RajouterPointEncrage(p,c2);
  RajouterPointEncrage(p,c3);
  
  printf("Liste des points d'encrage \n:");
  int i;
  for(i=0;i<p->tab_coordonnees->len;i++)
  {
      printf("Test points d'encrage : %g - %g \n",g_array_index(p->tab_coordonnees,Coordonnees,i).x,
	     g_array_index(p->tab_coordonnees,Coordonnees,i).y);
  }
  
  printf("Test de la fonction ModifPointEncrage et supprimer points d'encrage\n");
  ModifPointEncrage(p,2,c);
  SuppPointEncrage(p,2);
  for(i=0;i<p->tab_coordonnees->len;i++)
  {
      printf("Test points d'encrage2 : %g - %g \n",g_array_index(p->tab_coordonnees,Coordonnees,i).x,
	     g_array_index(p->tab_coordonnees,Coordonnees,i).y);
  }
  printf("OK\n");

  SupprimerPlume(p);
  assert(p->coorPl.x==0 &&
	 p->coorPl.y==0 &&
	 p->contour.r==0 &&
	 p->contour.g==0 &&
	 p->contour.b==0 &&
	 p->fond.r==0 &&
	 p->fond.g==0 &&
	 p->fond.b==0 &&
	 p->dimX==0 &&
	 p->dimY==0 &&
	 p->epaisseur_contour==0);

  printf("Test Module Plume manuellement: OK\n");
}

void TestStructureOutilsGraphique(int *argc, char ***argv)
{
  Carre car;
  Rectangle rec;
  Cercle cer;
  Plume p;
  int i;

  printf("\n\nTest regression des structures outils en mode graphique\n\n");

  gtk_clutter_init(argc,argv);
  AfficherEcran();
  CreerMenu();
  CreationBarreOutilsDessins(&car,&rec,&cer,&p);
  gtk_main();
  
  printf("Verification des donnees saisies pour la structure Rectangle :\n");
  printf("CoordonneesX : %g\n",rec.coordoRec.x); 	
  printf("CoordonneesY : %g\n",rec.coordoRec.y); 
  printf("Longueur : %g\n",rec.dimX); 
  printf("Largeur : %g\n",rec.dimY);      
  printf("Epaisseur : %g\n",rec.epaisseur_contour);        
  printf("Couleur Contour R : %g\n",rec.contour.r); 
  printf("Couleur Contour G : %g\n",rec.contour.g);
  printf("Couleur Contour B : %g\n",rec.contour.b);
  printf("Couleur Fond R : %g\n",rec.fond.r); 
  printf("Couleur Fond G : %g\n",rec.fond.g); 
  printf("Couleur Fond B : %g\n",rec.fond.b); 
  printf("Verification Rectangle : OK\n");

  printf("\nVerification des donnees saisies pour la structure Plume :\n");
  printf(" coordonnees en X : %g\n",p.coorPl.x); 	
  printf(" coordonnees en Y : %g\n",p.coorPl.y); 
  printf(" longueur : %g\n",p.dimX); 
  printf(" largeur : %g\n",p.dimY);      
  printf(" Epaisseur : %g\n",p.epaisseur_contour);        
  printf(" couleur contour R : %g\n",p.contour.r);
  printf(" couleur contour G : %g\n",p.contour.g);
  printf(" couleur contour B : %g\n",p.contour.b);
  printf(" couleur fond R : %g\n",p.fond.r);
  printf(" couleur fond G : %g\n",p.fond.g); 
  printf(" couleur fond B : %g\n",p.fond.b);

  for(i=0;i<p.tab_coordonnees->len;i++)
    {
      printf("Test points d'encrage : %g - %g \n",g_array_index(p.tab_coordonnees,Coordonnees,i).x,
             g_array_index(p.tab_coordonnees,Coordonnees,i).y);
    }
  printf("Verification Plume : OK\n");
 
  printf("\nVerification des donnees saisies pour la structure Cercle :\n");
  printf(" coordonnees en X : %g\n",cer.coordoCer.x); 	
  printf(" coordonnees en Y : %g\n",cer.coordoCer.y); 
  printf(" rayon du cercle : %g\n",cer.rayon);   
  printf(" Epaisseur : %g\n",cer.epaisseur_contour);        
  printf(" couleur contour R : %g\n",cer.contour.r); 
  printf(" couleur contour G : %g\n",cer.contour.g);
  printf(" couleur contour B : %g\n",cer.contour.b);
  printf(" couleur fond R : %g\n",cer.fond.r); 
  printf(" couleur fond G : %g\n",cer.fond.g); 
  printf(" couleur fond B : %g\n",cer.fond.b);
  printf("Verification Cercle : OK\n");

  printf("\nVerification des donnees saisies pour la structure Carre :\n");
  printf(" coordonnees en X : %g\n",car.coordoCar.x);
  printf(" coordonnees en Y : %g\n",car.coordoCar.y);
  printf(" dimension  du carre : %g\n",car.dim);
  printf(" Epaisseur : %g\n",car.epaisseur_contour);
  printf(" couleur R : %g\n",car.contour.r);
  printf(" couleur G : %g\n",car.contour.g);
  printf(" couleur B : %g\n",car.contour.b);
  printf(" couleur R : %g\n",car.fond.r);
  printf(" couleur G : %g\n",car.fond.g);
  printf(" couleur B : %g\n",car.fond.b);
  printf("Verification Carre : OK\n");
}
	
void TestStructureMarqueurScenarioGraphique(int *argc,char ***argv)
{
  Marqueur mq;
  Scenario sc;
  int i;

  printf("\nTest regression des structures Marqueur et Scenario :\n");
  printf("NE PAS APPUYER SUR LE BOUTER JOUER. Il faut juste rajouter les marqueur\n");
  printf("au scenario et fermer l'application pour voir si les marqueurs ont ete rempli correctement\n");

  InitScenario(&sc);

  gtk_clutter_init(argc,argv);
  CreerMenu();
  CreationBarreOutilsAnimation(&sc,&mq);
  gtk_main();
  
  printf("\nListe des marqueurs :\n\n");

  for(i=0;i<sc.tab_mq->len;i++)
    {
      mq = g_array_index(sc.tab_mq,Marqueur,i);

      printf("Duree : %d\n",mq.duree);
      printf("Nom marqueur : %s\n",mq.nom_marqueur);
      printf("Position Scenario : %d\n",mq.position_scenario);
      printf("Position Tableau : %d\n",mq.position_tableau);
      printf("Index Fonction : %d\n",mq.index_fonction);
      printf("Vitesse : %g\n",mq.vitesse);
      printf("Acceleration : %g\n",mq.acceleration);
      printf("\n\n");
    }
  printf("\n\n");
}
